﻿#define _CRT_SECURE_NO_WARNINGS 1

#include<assert.h>
#include<stdlib.h>
#include<iostream>
using namespace std;


//class Stack
//{
//public:
//	// 成员函数
//	void Init(int n = 4)
//	{
//		arr = (int*)malloc(sizeof(int) * n);
//		if (nullptr == arr)
//		{
//			perror("malloc申请空间失败");
//			return;
//		}
//		capacity = n;
//		top = 0;
//	}
//
//	void Push(int x)
//	{
//		// ...扩容
//		arr[top++] = x;
//	}
//
//	int Top()
//	{
//		assert(top > 0);
//		return arr[top - 1];
//	}
//
//	void Destroy()
//	{
//		free(arr);
//		arr = nullptr;
//		top = capacity = 0;
//	}
//
//private:
//	// 成员变量
//	int* arr;
//	size_t capacity;
//	size_t top;
//};
//
//int main()
//{
//	// 类名就是类型
//	Stack st1;
//	st1.Init();
//	st1.Push(1);
//	st1.Push(3);
//
//	cout << st1.Top() << endl;
//
//	st1.Destroy();
//
//	return 0;
//}




// C++升级struct升级成了类
// 1、类⾥⾯可以定义函数
// 2、struct名称就可以代表类型

//建议还是用class
//struct Person
//{
//public:
//	void Init(const char* name, int age)
//	{
//		strcpy(_name, name);
//		_age = age;
//	}
//
//	void Print()
//	{
//		cout << "姓名：" << _name << endl;
//		cout << "年龄：" << _age << endl;
//	}
//
//private:
//	//为了区分成员变量，⼀般习惯上成员变量
//	//会加⼀个特殊标识，如_ 或者 m开头
//	char _name[10];
//	int _age;
//};
//
//int main()
//{
//	Person pep;
//	pep.Init("天赐", 20);
//	pep.Print();
//
//	//不可以直接访问成员变量
//	//pep._age++;
//
//	return 0;
//}



 
// 兼容C的用法
//typedef struct QueueNode
//{
//	struct QueueNode* next;
//	int val;
//}QNode;
//
// 不再需要typedef，ListNode就可以代表类型
// struct ListNode
//{
//	ListNode* next;
//	int val;
//};
//
//typedef struct Queue
//{
//	QNode* head;
//	QNode* tail;
//	int size;
//}QU;
//
//void QueueInit(QU* q)
//{
//	q->head = nullptr;
//	q->tail = nullptr;
//	q->size = 0;
//}
//
//int main()
//{
//	QU q;
//	QueueInit(&q);
//
//	return 0;
//}




//class Queue
//{
//public:
//	void Init()
//	{}
//};

//标准类的声明和定义
//创建一个头文件和cpp文件
//#include"Stack.h"
//
//int main()
//{
//	Stack st;
//	st.Init();
//
//	return 0;
//}




//class Date
//{
//public:
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void Print()
//	{
//		cout << _year << " " << _month << " " << _day << endl;
//	}
//
//private:
//	//声明
//	int _year;
//	int _month;
//	int _day;
//};
//
//// 注意：声明不分配空间，定义才分配空间
//// 定义
//int year;
//
//int main()
//{
//	// 1->N
//	// 类实例化出对象
//	Date d1;
//	Date d2;
//	d1.Init(2024, 9, 16);
//	d2.Init(2025, 11, 2);
//
//	cout << &d1 << endl;
//	cout << &d2 << endl;
//
//	//依然不可以直接访问成员变量
//	//d1._year;
//	//d2._year;
//
//	d1.Print();
//	d2.Print();
//
//	cout << sizeof(d1) << endl;
//	cout << sizeof(d2) << endl;
//
//	return 0;
//}




//计算一下A/B/C实例化的对象是多大？
//class A
//{
//public:
//	void Print()
//	{
//		cout << _ch << endl;
//	}
//private:
//	char _ch;
//	int _i;
//};
//
//// 没有成员变量的类对象，开1byte，占位，不存储有效数据
//// 标识对象的存在
//class B
//{
//public:
//	void Print()
//	{
//		//...
//	}
//};
//
//class C
//{};
//
//int main()
//{
//	A a;
//	B b;
//	C c;
//
//	cout << sizeof(a) << endl;
//	cout << sizeof(b) << endl;
//	cout << sizeof(c) << endl;
//	cout << &b << endl;
//	cout << &c << endl;
//
//	return 0;
//}




//class Date
//{
//public:
//	// void Init(Date* const this, int year, int month, int day)
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	//void Print(Date* const this)
//	void Print()
//	{
//		//this = nullptr;
//		//一般不会写this指针
//		cout << this->_year << "/" << this->_month << "/" << this->_day << endl;
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	// 声明
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1;
//	Date d2;
//
//	//不能显示this指针，这样写会报错
//	//d1.Init(&d1, 2024, 9, 16);
//	//d2.Init(&d2, 2025, 11, 2);
//	d1.Init(2024, 9, 16);
//	d2.Init(2025, 11, 2);
//
//	//这里同样如此
//	//d1.Print(&d1);
//	//d2.Print(&d2);
//	d1.Print();
//	d2.Print();
//
//	return 0;
//}




//class A
//{
//public:
//	//Print函数中直接访问私有成员变量_a是合法的，因为Print是类A的成员函数。
//	//没有为_a提供构造函数或赋值语句，所以_a的值是未定义的，这可能会导致未定义行为。
//	//没有提供类的构造函数，这意味着_a会被默认初始化，对于基本数据类型int来说，其值将是未定义的。
//	void Print()
//	{
//		cout << "A::Print()" << endl;
//		cout << _a << endl;
//	}
//private:
//	int _a;
//};
//
//int main()
//{
//	A* p = nullptr;
//	p->Print();
//
//	Date d1;
//	d1.Init(2024, 9, 16);
//
//	return 0;
//}




//class Date
//{
//public:
//	// 如果没有写无参和全缺省函数
//	// 编译器会默认生成一个构造函数，但不一定满足我们的需求
//	// 并且这三个函数有且只能有一种存在
//	//⽆参构造函数
//	Date()
//	{
//		_year = 1;
//		_month = 1;
//		_day = 1;
//	}
//	//全缺省构造函数
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	//这不属于默认构造函数
//	//带参构造函数
//	Date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void Print()
//	{
//		cout << _year << " " << _month << " " << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	//如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器会报错
//	//Date d1();
//
//	//不传实参调用构造，都叫默认构造
//	Date d1;
//	d1.Print();
//
//	Date d2(2024, 9, 16);
//	d2.Print();
//
//	Date d3(2024);
//	d3.Print();
//
//	return 0;
//}




//class Date
//{
//public:
//	Date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void Print()
//	{
//		cout << _year << " " << _month << " " << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	// 不传实参调用构造，才叫默认构造
//	
//	//这里初始化要传实参，所以不叫默认构造函数
//	Date d1(2024, 9, 16); 
//	d1.Print();
//
//	return 0;
//}




//class Date
//{
//public:
//	void Print()
//	{
//		cout << _year << " " << _month << " " << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//typedef int STDataType;
//class Stack
//{
//public:
//	Stack(int n)
//	{
//		_a = (STDataType*)malloc(sizeof(STDataType) * n);
//		if (nullptr == _a)
//		{
//			perror("malloc fail!");
//			exit(2);
//		}
//		_capacity = n;
//		_top = 0;
//	}
//
//private:
//	STDataType* _a;
//	size_t _capacity;
//	size_t _top;
//};
//
//// 两个栈实现一个队列
//class MyQueue
//{
//private:
//	Stack _pushst;
//	Stack _popst;
//	int _size;
//};
//
//int main()
//{
//	// 不传实参调用构造，都叫默认构造
//	Date d1;
//	d1.Print();
//
//	Stack st1(4);
//
//	MyQueue q;
//
//	return 0;
//}